import { API } from '../../config/api.js';

Page({
  data: {
    activeTab: "process",
    visaData: {}, // 用于存储当前签证数据（现在包含了id）
    showProcessModal: false,
    showApplicantSelector: false,
    showIdentitySelector: false,
    showAddForm: false, // 申请人
    travelDate: '', // 初始为空字符串
    defaultDate: (() => {
      const date = new Date();
      const year = date.getFullYear();
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const day = String(date.getDate()).padStart(2, '0');
      return `${year}-${month}-${day}`; 
    })(), // 默认日期，用于picker的起始值
    newApplicantName: "", // 用于存储输入的申请人姓名
    selectedApplicant: null,
    identityOptions: [], // 改为空数组，将根据模板动态设置
    selectedIdentity: "",
    // 新增材料要求相关数据
    showMaterialDetailModal: false,
    currentMaterial: '',
    materialRequirements: [],
    materialModalHeight: 360, // 初始高度（px），会根据内容动态计算
    // 新增材料模板相关数据
    materialTemplates: [], // 材料模板列表
    materialList: [], // 当前产品的材料列表
    materialLoading: false // 材料加载状态
  },
    // 打开办理弹窗
    openProcessModal() {
      this.setData({ showProcessModal: true });
    },
  
    // 关闭办理弹窗
    closeProcessModal() {
      this.setData({ showProcessModal: false });
    },
  
    // 选择出行时间
    onDateChange(e) {
      this.setData({ travelDate: e.detail.value });
    },
    // 选择申请人
    openApplicantSelector() {
      this.setData({ showApplicantSelector: true });
    },
    closeProcesslist(){
      this.setData({showApplicantSelector:false})
    },
  
  
    closeApplicantSelector() {
      this.setData({ showApplicantSelector: false });
    },
  
    confirmApplicants() {
      this.setData({
        showApplicantSelector: false
      });
    },
  // 申请人输入
  onNameInput(e) {
    this.setData({
      newApplicantName: e.detail.value
    });
  },

  // 修改：确认申请人
  confirmApplicants() {
    if (this.data.newApplicantName.trim()) {
      this.setData({
        selectedApplicantName: this.data.newApplicantName,
        selectedApplicants: [this.data.newApplicantName], // 将选中的申请人存入数组
        showApplicantSelector: false,
        newApplicantName: "" // 清空输入框
      });
    } else {
      wx.showToast({
        title: '请输入申请人姓名',
        icon: 'none'
      });
    }
  },

// 显示添加申请人表单
showAddApplicantForm() {
  this.setData({
    showAddForm: true,
    newApplicantName: '',
    selectedIdentity: ''
  });
},

// 获取模板ID和人员类型
async fetchTemplateId(productId) {
  console.log('开始获取模板ID, productId:', productId);
  try {
    // 获取全局配置的baseUrl
    const app = getApp();
    const baseUrl = app.globalData.baseUrl;
    
    const res = await new Promise((resolve, reject) => {
      wx.request({
        url: API.visaTemplate.getByProductId,
        method: 'GET',
        data: {
          productId: productId
        },
        header: {
          'content-type': 'application/json',
          'token': wx.getStorageSync('token')
        },
        success: (res) => {
          console.log('请求成功，返回数据:', res.data); // 添加调试信息
          resolve(res);
        },
        fail: (err) => {
          console.error('请求失败，错误信息:', err); // 添加调试信息
          reject(err);
        }
      });
    });

    if (res.data.code === 1 && res.data.data) {
      // 直接使用返回的数组，因为它已经是模板ID列表了
      this.setData({
        'visaData.templateIds': res.data.data
      });
      console.log('保存的模板ID列表:', this.data.visaData.templateIds); // 添加调试信息
      
      // 获取模板人员类型
      await this.fetchTemplateUserTypes(productId);
    } else {
      console.error('获取模板ID失败:', res.data.msg);
    }
  } catch (err) {
    console.error('获取模板ID失败:', err);
  }
},

// 获取模板人员类型
async fetchTemplateUserTypes(productId) {
  console.log('开始获取模板人员类型, productId:', productId);
  try {
    const app = getApp();
    const baseUrl = app.globalData.baseUrl;
    
    const res = await new Promise((resolve, reject) => {
      wx.request({
        url: `${API.visaTemplate.getUserTypesByProductId}/${productId}`,
        method: 'GET',
        header: {
          'content-type': 'application/json'
        },
        success: (res) => {
          console.log('获取模板人员类型成功，返回数据:', res.data);
          resolve(res);
        },
        fail: (err) => {
          console.error('获取模板人员类型失败，错误信息:', err);
          reject(err);
        }
      });
    });

    if (res.data.code === 1 && res.data.data && res.data.data.length > 0) {
      // 将后端的人员类型(字段组)映射为小程序显示的人员类型
      const userTypeMapping = {
        '在职': '在职人员',
        '自由职业': '自由职业者', 
        '退休': '退休人员',
        '学生': '在校学生',
        '儿童': '学龄前儿童',
        '全部': '全部'
      };
      
      const identityOptions = res.data.data
        .map(backendType => userTypeMapping[backendType])
        .filter(type => type) // 过滤掉未映射的类型
        .filter((type, index, arr) => arr.indexOf(type) === index); // 去重
      
      console.log('设置的人员类型选项:', identityOptions);
      this.setData({
        identityOptions: identityOptions
      });
    } else {
      console.log('没有找到模板人员类型或模板为空，使用默认选项');
      // 如果没有模板或获取失败，使用默认选项
      this.setData({
        identityOptions: ["在职人员", "自由职业者", "退休人员", "在校学生", "学龄前儿童"]
      });
    }
  } catch (err) {
    console.error('获取模板人员类型失败:', err);
    // 如果获取失败，使用默认选项
    this.setData({
      identityOptions: ["在职人员", "自由职业者", "退休人员", "在校学生", "学龄前儿童"]
    });
  }
},

openinformation() {
  if (!this.data.travelDate) {
    wx.showToast({
      title: '请选择出行时间',
      icon: 'none'
    });
    return;
  }
  if (!this.data.selectedApplicant) {
    wx.showToast({
      title: '请添加申请人',
      icon: 'none'
    });
    return;
  }
  wx.navigateTo({
    url: '/pages/information/information',
    success: (res) => {
      res.eventChannel.emit('acceptApplicantData', {
        applicants: [this.data.selectedApplicant],
        price: this.data.visaData.price,
        visaInfo: {
          title: this.data.visaData.title,
          city: this.data.visaData.city,
          templateIds: this.data.visaData.templateIds // 传递模板ID列表
        },
        cityInfo: {
          city: `${this.data.visaData.city}领区`,
          date: this.data.travelDate
        },
        identity: this.data.selectedApplicant.identity,
        initialStatus: {
          electronic: false,
          paper: false
        }
      });
    }
  });
},
// 确认添加申请人
  confirmAddApplicant() {
    if (!this.data.newApplicantName.trim()) {
      wx.showToast({
        title: '请输入申请人姓名',
        icon: 'none'
      });
      return;
    }
    if (!this.data.selectedIdentity) {
      wx.showToast({
        title: '请选择旅客身份',
        icon: 'none'
      });
      return;
    }

    // 创建申请人对象
    const applicant = {
      name: this.data.newApplicantName,
      identity: this.data.selectedIdentity
    };

    this.setData({
      selectedApplicant: applicant,
      selectedApplicants: [applicant], // 保持数组格式，但只包含一个申请人
      showAddForm: false,
      newApplicantName: '',
      selectedIdentity: ''
    });
  

  const newApplicant = {
    name: this.data.newApplicantName,
    identity: this.data.selectedIdentity
  };

  this.setData({
    selectedApplicants: [...this.data.selectedApplicants, newApplicant],
    showAddForm: false,
    newApplicantName: '',
    selectedIdentity: ''
  });
},

// 取消添加申请人
cancelAddApplicant() {
  this.setData({
    showAddForm: false,
    newApplicantName: '',
    selectedIdentity: ''
  });
},

  // 删除申请人
  deleteApplicant(e) {
    const index = e.currentTarget.dataset.index;
    const newApplicants = [...this.data.selectedApplicants];
    newApplicants.splice(index, 1);
    this.setData({
      selectedApplicants: newApplicants,
      selectedApplicantName: newApplicants.map(app => app.name).join('、')
    });
  },
  
  // 修改：关闭选择器时清空输入
  closeApplicantSelector() {
    this.setData({
      showApplicantSelector: false,
      newApplicantName: ""
    });
  },
    // 选择旅客身份
    openIdentitySelector() {
      this.setData({ showIdentitySelector: true });
    },
  
    selectIdentity(e) {
      this.setData({ selectedIdentity: e.detail.value });
    },
  
    confirmIdentity() {
      this.setData({ showIdentitySelector: false });
    },
  
    // 跳转到订单页面
    goToOrder(e) {
      wx.navigateTo({
        url: "/pages/order/order"
      });
    },

  onLoad(options) {
    const eventChannel = this.getOpenerEventChannel();
    eventChannel.on('acceptDataFromOpenerPage', (data) => {
      // 格式化日期字符串为 YYYY-MM-DD 格式
      const formatDate = (dateStr) => {
        if (!dateStr || dateStr.length !== 8) return '';
        return `${dateStr.slice(0, 4)}-${dateStr.slice(4, 6)}-${dateStr.slice(6)}`;
      };

      const startDate = formatDate(data.visaData.startDate);
      const endDate = formatDate(data.visaData.endDate);
      
      this.setData({
        visaData: data.visaData,
        minDate: startDate || '',
        maxDate: endDate || '',
        travelDate: startDate || '',
        userNotice: data.visaData.userNotice,
        title: options.title || '',
        city: options.city || '',
        processingTime: options.transact_time || '', // 修改为 transact_time
        price: options.price || '',
        validityPeriod: options.validityPeriod || '',
        entryTimes: options.entryTimes || '',
        processingDuration: options.processingDuration || '',
        maxStay: options.max_stay || '',
        serviceIncludes: options.serviceIncludes || '',
        notice: options.notice || '',
        showCalendar: false,
        months: [],
        selectedDate: null
      });
      
      // 获取产品对应的模板ID和材料列表
      this.fetchTemplateId(data.visaData.id);
      // 先获取材料模板，再获取产品材料
      this.fetchMaterialTemplates().then(() => {
        this.fetchProductMaterials(data.visaData.id);
      });
    });
  },

  
  // 显示日期选择器
  showDatePicker() {
    const months = this.generateMonths();
    this.setData({
      showCalendar: true,
      months
    });
  },

  // 隐藏日期选择器
  hideDatePicker() {
    this.setData({
      showCalendar: false
    });
  },

  generateMonths() {
    const months = [];
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    
    const minDateObj = this.data.minDate ? new Date(this.data.minDate + 'T00:00:00') : today;
    const maxDateObj = this.data.maxDate ? new Date(this.data.maxDate + 'T23:59:59') : new Date(today.getFullYear(), today.getMonth() + 12, 0);
  
    let currentDate = new Date(minDateObj);
    
    while (currentDate <= maxDateObj) {
      const year = currentDate.getFullYear();
      const month = currentDate.getMonth() + 1;
      
      const firstDay = new Date(year, month - 1, 1).getDay();
      const daysInMonth = new Date(year, month, 0).getDate();
      
      const days = [];
      let hasValidDateInWeek = false;
      let weekDays = [];
      
      // 添加月初的空白天数
      for (let i = 0; i < firstDay; i++) {
        weekDays.push({ day: '', isValid: false });
      }
      
      // 添加实际日期
      for (let day = 1; day <= daysInMonth; day++) {
        const date = new Date(year, month - 1, day);
        date.setHours(0, 0, 0, 0);
        
        const isInRange = date >= minDateObj && date <= maxDateObj && date >= today;
        const dateStr = this.formatDate(date);
        
        weekDays.push({
          day,
          isToday: this.isToday(date),
          isValid: isInRange,
          disabled: !isInRange && day !== '', // 添加 disabled 标记
          fullDate: dateStr,
          isSelected: this.data.selectedDate === dateStr
        });
  
        // 如果是周六或月末，检查这一周是否有有效日期，然后添加到days数组
        if (weekDays.length === 7 || day === daysInMonth) {
          const hasValidDate = weekDays.some(d => d.isValid);
          if (hasValidDate) {
            days.push(...weekDays);
            hasValidDateInWeek = true;
          }
          weekDays = [];
        }
      }
  
      // 如果月份中有有效日期，则添加到月份列表
      if (hasValidDateInWeek) {
        months.push({
          year,
          month,
          days
        });
      }
  
      currentDate.setMonth(currentDate.getMonth() + 1);
    }
  
    return months;
  },


  // 检查是否是今天
  isToday(date) {
    const today = new Date();
    return date.getDate() === today.getDate() &&
           date.getMonth() === today.getMonth() &&
           date.getFullYear() === today.getFullYear();
  },

  // 格式化日期
  formatDate(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`;
  },

  // 选择日期
  selectDate(e) {
    const date = e.currentTarget.dataset.date;
    if (!date) return; // 如果点击的是空白日期，直接返回
    
    // 检查日期是否在有效范围内
    const selectedDate = new Date(date + 'T00:00:00');
    const minDate = this.data.minDate ? new Date(this.data.minDate + 'T00:00:00') : new Date();
    const maxDate = this.data.maxDate ? new Date(this.data.maxDate + 'T23:59:59') : null;
    
    // 添加调试日志
    console.log('日期选择:', {
      selectedDate: selectedDate.toISOString(),
      minDate: minDate.toISOString(),
      maxDate: maxDate ? maxDate.toISOString() : null,
      isBeforeMin: selectedDate < minDate,
      isAfterMax: maxDate ? selectedDate > maxDate : false
    });

    if (selectedDate < minDate || (maxDate && selectedDate > maxDate)) {
      wx.showToast({
        title: '所选日期超出可选范围',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      selectedDate: date,
      travelDate: date,
      showCalendar: false
    });
  },

  // 确认日期选择
  confirmDate() {
    if (this.data.selectedDate) {
      this.setData({
        travelDate: this.data.selectedDate,
        showCalendar: false
      });
    }
  },

  // 修改日期选择器的事件处理
  bindDateChange(e) {
    const selectedDate = e.detail.value;
    // 验证所选日期是否在范围内
    if (this.data.minDate && selectedDate < this.data.minDate) {
      wx.showToast({
        title: '不能选择早于' + this.data.minDate + '的日期',
        icon: 'none'
      });
      return;
    }
    if (this.data.maxDate && selectedDate > this.data.maxDate) {
      wx.showToast({
        title: '不能选择晚于' + this.data.maxDate + '的日期',
        icon: 'none'
      });
      return;
    }
    this.setData({
      travelDate: selectedDate
    });
  },

  // 切换选项卡
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({
      activeTab: tab
    });
  
    // 根据选项卡滚动到对应的内容部分
    let targetId = '';
    if (tab === 'process') {
      targetId = 'process-section';
    } else if (tab === 'materials') {
      targetId = 'materials-section';
    } else if (tab === 'tips') {
      targetId = 'tips-section';
    }
  
    if (targetId) {
      // 使用createSelectorQuery获取目标元素位置
      const query = wx.createSelectorQuery();
      query.select(`#${targetId}`).boundingClientRect();
      query.selectViewport().scrollOffset();
      query.exec((res) => {
        if (res[0] && res[1]) {
          const targetTop = res[0].top;
          const scrollTop = res[1].scrollTop;
          const offset = 80; // 偏移量，确保标题不被选项卡遮挡
          
          wx.pageScrollTo({
            scrollTop: scrollTop + targetTop - offset,
            duration: 300
          });
        }
      });
    }
  },

  // 返回上一页
  goBack() {
    wx.navigateBack();
  },

  // 跳转到客服页面
  contactSupport() {
    wx.navigateTo({
      url: "/pages/contactSupport/contactSupport"
    });
  },

  // 跳转到办理页面
  startProcess() {
    wx.navigateTo({
      url: "/pages/startProcess/startProcess"
    });
  },

  // 显示材料要求明细
  showMaterialDetail(e) {
    const material = e.currentTarget.dataset.material;
    const materialItem = this.data.materialList.find(item => item.materialName === material);
    
    console.log('显示材料要求明细:', {
      material: material,
      materialItem: materialItem,
      selectedApplicant: this.data.selectedApplicant,
      visaData: this.data.visaData
    });
    
    // 检查是否有材料要求
    if (!materialItem || !materialItem.hasRequirements) {
      wx.showToast({
        title: '该材料暂无详细要求',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      currentMaterial: material,
      showMaterialDetailModal: true
    });
    
    // 阻止主页面滚动
    wx.pageScrollTo({
      scrollTop: 0,
      duration: 0
    });
    
    // 获取材料要求数据
    this.fetchMaterialRequirements(material);
  },
  
  // 计算弹窗高度（最多按3条显示高度）
  computeMaterialModalHeight(count) {
    // 头部高度 + 每条卡片高度估算 + 内边距
    const headerHeight = 64; // px
    const itemHeight = 108;  // px，含margin/padding的近似值
    const verticalPadding = 24; // px
    const maxVisible = 3;
    const visibleCount = Math.min(Math.max(count, 0), maxVisible);

    // 至少给一个最小高度（当0条时）
    const minBody = itemHeight * (count === 0 ? 1 : visibleCount);
    const total = headerHeight + verticalPadding * 2 + minBody;

    // 同时不超过屏幕高度的80%
    const systemInfo = wx.getSystemInfoSync();
    const maxHeight = Math.floor(systemInfo.windowHeight * 0.8);
    return Math.min(total, maxHeight);
  },

  // 关闭材料要求明细
  closeMaterialDetailModal() {
    this.setData({
      showMaterialDetailModal: false,
      currentMaterial: '',
      materialRequirements: []
    });
  },

  // 阻止页面滚动
  preventScroll(e) {
    e.preventDefault();
    e.stopPropagation();
    return false;
  },

  // 获取材料要求数据
  async fetchMaterialRequirements(materialName) {
    try {
      wx.showLoading({ title: '加载中...' });
      
      // 获取当前签证产品ID
      const productId = this.data.visaData.id;
      
      if (!productId) {
        wx.showToast({
          title: '产品信息不完整',
          icon: 'none'
        });
        return;
      }

      // 人员类型映射：小程序类型 -> 数据库类型
      const userTypeMapping = {
        '在职人员': '在职',
        '自由职业者': '自由职业',
        '退休人员': '退休',
        '在校学生': '学生',
        '学龄前儿童': '儿童',
        '全部': '全部'
      };

      // 获取当前申请人的用户类型
      const currentUserType = this.data.selectedApplicant ? this.data.selectedApplicant.identity : null;
      const dbUserType = currentUserType ? userTypeMapping[currentUserType] : null;

      console.log('当前用户类型映射:', {
        currentUserType: currentUserType,
        dbUserType: dbUserType,
        mapping: userTypeMapping
      });

      // 始终查询所有材料要求，然后在客户端进行过滤
      const res = await new Promise((resolve, reject) => {
        wx.request({
          url: `${API.materialRequirement.getByProductId}/${productId}`,
          method: 'GET',
          header: {
            'content-type': 'application/json'
          },
          success: resolve,
          fail: reject
        });
      });

      if (res.data.code === 1 && Array.isArray(res.data.data)) {
        const allRequirements = res.data.data;
        
        // 过滤出当前材料的要求，并且符合用户类型或"全部"类型
        const filteredRequirements = allRequirements.filter(item => {
          const materialMatch = item.materialName && item.materialName.includes(materialName);
          if (!materialMatch) return false;
          
          // 如果材料要求没有指定用户类型（userType为空），则适用于所有用户
          if (!item.userType || item.userType.trim() === '') {
            return true;
          }
          
          // 如果指定了用户类型，则按原逻辑过滤
          if (!dbUserType) return true;
          return item.userType === '全部' || item.userType === dbUserType;
        });
        
        // 根据数量计算弹窗高度
        const modalHeight = this.computeMaterialModalHeight(filteredRequirements.length);
        
        this.setData({
          materialRequirements: filteredRequirements,
          materialModalHeight: modalHeight
        });
      } else {
        // 无数据时给出最小高度（显示提示区域）
        const modalHeight = this.computeMaterialModalHeight(0);
        this.setData({
          materialRequirements: [],
          materialModalHeight: modalHeight
        });
      }
    } catch (error) {
      console.error('获取材料要求失败：', error);
      wx.showToast({
        title: '获取材料要求失败',
        icon: 'none'
      });
      const modalHeight = this.computeMaterialModalHeight(0);
      this.setData({
        materialRequirements: [],
        materialModalHeight: modalHeight
      });
    } finally {
      wx.hideLoading();
    }
  },

  // 获取材料模板列表
  async fetchMaterialTemplates() {
    try {
      console.log('开始获取材料模板，请求URL：', API.materialTemplate.list);
      
      const res = await new Promise((resolve, reject) => {
        wx.request({
          url: API.materialTemplate.list,
          method: 'GET',
          header: {
            'content-type': 'application/json'
          },
          success: resolve,
          fail: reject
        });
      });

      console.log('材料模板接口响应：', res);
      console.log('响应数据：', res.data);

      if (res.data.code === 1 && Array.isArray(res.data.data)) {
        // 使用 Promise 确保 setData 完成后再返回
        return new Promise((resolve) => {
          this.setData({
            materialTemplates: res.data.data
          }, () => {
            console.log('获取材料模板成功，数量：', res.data.data.length);
            console.log('材料模板详情：', res.data.data);
            console.log('setData 完成，当前 materialTemplates：', this.data.materialTemplates);
            resolve(res.data.data);
          });
        });
      } else {
        console.log('获取材料模板失败或无数据，响应：', res.data);
        return [];
      }
    } catch (error) {
      console.error('获取材料模板失败：', error);
      return [];
    }
  },

  // 获取产品材料要求
  async fetchProductMaterials(productId) {
    try {
      this.setData({ materialLoading: true });
      
      console.log('开始获取产品材料要求，productId:', productId);
      console.log('获取前检查材料模板状态：', this.data.materialTemplates.length);
      
      const res = await new Promise((resolve, reject) => {
        wx.request({
          url: `${API.materialRequirement.getByProductId}/${productId}`,
          method: 'GET',
          header: {
            'content-type': 'application/json'
          },
          success: resolve,
          fail: reject
        });
      });

      console.log('产品材料要求接口响应：', res.data);

      if (res.data.code === 1 && Array.isArray(res.data.data)) {
        // 确保材料模板已加载
        if (this.data.materialTemplates.length === 0) {
          console.warn('材料模板未加载，等待加载完成...');
          // 等待材料模板加载完成
          let retryCount = 0;
          const checkTemplates = () => {
            if (this.data.materialTemplates.length > 0) {
              console.log('材料模板已加载，开始处理材料列表');
              this.processMaterialList(res.data.data);
            } else if (retryCount < 10) {
              retryCount++;
              console.log(`等待材料模板加载，重试次数：${retryCount}`);
              setTimeout(checkTemplates, 200);
            } else {
              console.error('材料模板加载超时，使用默认材料列表');
              this.setDefaultMaterialList();
            }
          };
          checkTemplates();
        } else {
          this.processMaterialList(res.data.data);
        }
      } else {
        this.setDefaultMaterialList();
      }
    } catch (error) {
      console.error('获取产品材料要求失败：', error);
      this.setDefaultMaterialList();
    } finally {
      this.setData({ materialLoading: false });
    }
  },

  // 处理材料列表
  processMaterialList(productMaterials) {
    console.log('开始处理材料列表');
    console.log('产品材料数据：', productMaterials);
    console.log('当前材料模板：', this.data.materialTemplates);
    console.log('材料模板数量：', this.data.materialTemplates.length);
    
    // 如果材料模板为空，延迟处理
    if (!this.data.materialTemplates || this.data.materialTemplates.length === 0) {
      console.warn('材料模板为空，延迟500ms后重试');
      setTimeout(() => {
        console.log('重试处理材料列表，当前模板数量：', this.data.materialTemplates.length);
        if (this.data.materialTemplates.length > 0) {
          this.processMaterialList(productMaterials);
        } else {
          console.error('材料模板仍为空，使用默认材料列表');
          this.setDefaultMaterialList();
        }
      }, 500);
      return;
    }
    
    // 创建产品材料Map，用于查找是否有具体要求
    const productMaterialMap = new Map();
    productMaterials.forEach(item => {
      if (!productMaterialMap.has(item.materialName)) {
        productMaterialMap.set(item.materialName, item);
      }
    });
    
    console.log('产品材料Map：', Array.from(productMaterialMap.entries()));
    
    // 材料名称映射（临时解决数据不一致问题）
    const materialNameMapping = {
      '出生证明': '婚姻状况',
      // 可以在这里添加更多映射
    };
    
    // 基于所有材料模板创建材料列表
    const materialList = [];
    
    this.data.materialTemplates.forEach(template => {
      // 检查这个模板是否在产品材料要求中
      let productMaterial = productMaterialMap.get(template.materialName);
      let hasRequirements = !!productMaterial;
      
      // 如果没有直接匹配，检查是否有反向映射
      if (!hasRequirements) {
        // 查找是否有其他材料映射到这个模板
        for (const [originalName, mappedName] of Object.entries(materialNameMapping)) {
          if (mappedName === template.materialName && productMaterialMap.has(originalName)) {
            productMaterial = productMaterialMap.get(originalName);
            hasRequirements = true;
            console.log(`模板 ${template.materialName} 通过反向映射 ${originalName} 找到产品材料：`, productMaterial);
            break;
          }
        }
      }
      
      console.log(`模板 ${template.materialName}：hasRequirements=${hasRequirements}`);
      
      materialList.push({
        id: productMaterial ? productMaterial.id : template.id,
        materialName: template.materialName,
        materialImageUrl: template.materialIconUrl,
        hasRequirements: hasRequirements
      });
    });
    
    console.log('基于模板创建的材料列表：', materialList);
    
    // 按排序序号排序
    materialList.sort((a, b) => {
      const templateA = this.data.materialTemplates.find(t => t.materialName === a.materialName);
      const templateB = this.data.materialTemplates.find(t => t.materialName === b.materialName);
      return (templateA?.sortOrder || 999) - (templateB?.sortOrder || 999);
    });
    
    console.log('排序后的最终材料列表：', materialList);
    
    this.setData({
      materialList: materialList
    });
  },

  // 设置默认材料列表（兜底方案）
  setDefaultMaterialList() {
    const defaultMaterials = [
      {
        id: 'default_1',
        materialName: '证件照',
        materialImageUrl: 'https://visa.goldenholiday.com/images/country/Photograph.png',
        hasRequirements: true
      },
      {
        id: 'default_2',
        materialName: '护照首页',
        materialImageUrl: 'https://visa.goldenholiday.com/images/country/Passprot.png',
        hasRequirements: true
      },
      {
        id: 'default_3',
        materialName: '身份证',
        materialImageUrl: 'https://visa.goldenholiday.com/images/country/Identity.png',
        hasRequirements: true
      },
      {
        id: 'default_4',
        materialName: '婚姻状况',
        materialImageUrl: 'https://visa.goldenholiday.com/images/country/Marriage.png',
        hasRequirements: true
      },
      {
        id: 'default_5',
        materialName: '户口本',
        materialImageUrl: 'https://visa.goldenholiday.com/images/country/Booklet.png',
        hasRequirements: true
      },
      {
        id: 'default_6',
        materialName: '银行流水',
        materialImageUrl: 'https://visa.goldenholiday.com/images/country/Statement.png',
        hasRequirements: true
      }
    ];
    
    this.setData({
      materialList: defaultMaterials
    });
    
    console.log('使用默认材料列表');
  },

  // 获取默认材料图片
  getDefaultMaterialImage(materialName) {
    const defaultImages = {
      '证件照': 'https://visa.goldenholiday.com/images/country/Photograph.png',
      '护照首页': 'https://visa.goldenholiday.com/images/country/Passprot.png',
      '身份证': 'https://visa.goldenholiday.com/images/country/Identity.png',
      '婚姻状况': 'https://visa.goldenholiday.com/images/country/Marriage.png',
      '户口本': 'https://visa.goldenholiday.com/images/country/Booklet.png',
      '银行流水': 'https://visa.goldenholiday.com/images/country/Statement.png'
    };
    
    return defaultImages[materialName] || 'https://visa.goldenholiday.com/images/country/default-material.png';
  }
});
